home *** CD-ROM | disk | FTP | other *** search
/ ASME's Mechanical Engine…ing Toolkit 1997 December / ASME's Mechanical Engineering Toolkit 1997 December.iso / ai / preds.lzh / PREDS2.PRO < prev   
Text File  |  1986-05-29  |  5KB  |  198 lines
  1. /* 
  2. THESE ARE SOME USEFUL PROLOG PREDICATES FOR MANIPULATING LISTS AND A
  3. REAL ARITHMETIC FUNCTION OMITTED FROM TPROLOG. THE LIST DOMAIN AND PREDICATE
  4. DECLARATIONS ONLY ASSUME YOU'RE MANIPULATING SYMBOLS AND LISTS OF SYMBOLS.
  5. ADDITIONAL DOMAIN AND PREDICATE DECLARATIONS CAN MAKE THESE PREDICATES
  6. HANDLE OTHER DATA TYPES.
  7.  
  8. COMPILED BY JOHN REECE FROM C&M AND B&H
  9. */
  10.  
  11. domains
  12.  
  13.   list = symbol* 
  14.  
  15. predicates
  16.   true                               /* Standard Prolog predicate omitted from Turbo Prolog */
  17.   repeat                             /* Standard Prolog predicate omitted from Turbo Prolog */
  18.   raise(real,real,real)              /* Raise a base to a real, positive or negative exponent */
  19.  
  20.   append(list,list,list)             /* Append two lists into the third */
  21.   member(symbol,list)                /* Is symbol a member of the list? */
  22.   
  23.                                      /* Most of these need member() or append() */
  24.  
  25.   nth(symbol,integer,list)           /* Remove the nth symbol from the list */
  26.   last(symbol,list)                  /* Get the last symbol in the list */
  27.   remove(symbol,list,list)           /* Remove all occurrences of symbol from the list */
  28.   length(list,integer)               /* Number of elements in the list */
  29.   flen(list,integer,integer)         /* Subroutine for length() */
  30.   permute(list,list)                 /* Returns all the possible rearrangements of a list */
  31.   reverse(list,list)                 /* Reverse a list */
  32.   reverse1(list,list,list)           /* Subroutine for reverse() */
  33.   efface(symbol,list,list)           /* Remove the first occurence of symbol from a list*/
  34.   subst(symbol,list,symbol,list)     /* Replace all occurrences of the first symbol in the first list with the second symbol */
  35.   subset(list,list)                  /* Is the first list a subset of the second? */
  36.   intersection(list,list,list)       /* Intersection of two lists */
  37.   union(list,list,list)              /* Union of two lists */
  38.   quicksort(list,list)               /* Quick sort a list of symbols */
  39.   split(symbol,list,list,list)       /* Subroutine for quicksort() */
  40.   
  41. clauses
  42.  
  43. /*
  44. TRUE PREDICATE FROM STANDARD PROLOG
  45. */
  46. true if
  47.    not(not(fail)).
  48.  
  49. /*
  50. REPEAT PREDICATE FROM STANDARD PROLOG
  51. */
  52. repeat.
  53. repeat if repeat. 
  54.  
  55. /*
  56. RAISE A BASE TO A REAL, POSITIVE OR NEGATIVE EXPONENT, RETURNING RESULT.
  57. */
  58. raise(_,Power,Result) if
  59.     Power = 0 and
  60.     Result = 1.0.
  61.     
  62. raise(Base,Power,Result) if
  63.     Power < 0 and
  64.     Term1 = 0.0 - Power and
  65.     raise(Base,Term1,TempResult) and
  66.     Result = 1/TempResult.
  67.  
  68. raise(Base,Power,Result) if
  69.     Power > 0 and
  70.     Result = exp(Power * ln(Base)).  
  71.   
  72. /*
  73. CONCATENATE TWO LISTS INTO LIST Y.
  74. */
  75. append([],L,L).
  76. append([X|L1],L2,[X|L3]) if
  77.      append(L1,L2,L3).
  78.  
  79. /*
  80. IS X A MEMBER OF THE LIST?     
  81. */
  82. member(X, [X|_]).
  83. member(X, [_|Y]) if member(X, Y).
  84.  
  85.  
  86. /*
  87. FIND THE nTH MEMBER OF A LIST
  88. */
  89. nth(X, 1, [X|_]).
  90. nth(X, N, [_|L]) if R = N-1,
  91.                     nth(X, R, L).
  92.  
  93. /*
  94. FIND THE LAST ELEMENT X IN A LIST.
  95. */
  96. last(X,[X]).
  97. last(X,[_|L]) if last(X,L).
  98.  
  99. /* 
  100. REMOVE THE GIVEN ITEM X FROM THE LIST, RETURNING L.
  101. */
  102. remove(X,[X|T],L) if
  103.       remove(X,T,L),
  104.       !.
  105. remove(X,[X|T],T).
  106. remove(X,[H|T],[H|L]) if
  107.       remove(X,T,L).
  108. /*
  109. FIND THE LENGTH OF A LIST
  110. */
  111. length(X,J) if
  112.       flen(X,J,0).
  113.  
  114. flen([],Y,Y).
  115. flen([_|T],Y,Z) if
  116.       P = Z + 1,
  117.       flen(T, Y, P).
  118.  
  119. /*
  120. RETURN ALL PERMUTATIONS OF LIST 
  121. */
  122. permute([],[]).
  123. permute(L,[H|T]) if
  124.       append(V,[H|U],L) and
  125.       append(V,U,W) and
  126.       permute(W,T).
  127.  
  128. /*
  129. REVERSE A LIST
  130. */
  131. reverse(L1,L2) if
  132.        reverse1(L1,[],L2).
  133. reverse1([X|L],L2,L3) if
  134.        reverse1(L,[X|L2],L3).
  135. reverse1([],L,L).
  136.  
  137. /* 
  138. EFFACE(X,Y,Z) REMOVES THE FIRST OCCURENCE OF ELEMENT X FROM LIST Z
  139. */
  140. efface(A,[A|L],L) if !.
  141. efface(A,[B|L],[B|M]) if
  142.     efface(A,L,M).
  143.     
  144. /*
  145. SUBST(X,L,A,M) CONSTRUCTS NEW LIST M FROM LIST L REPLACING ALL ELEMENTS
  146. X WITH ELEMENT A
  147. */
  148. subst(_,[],_,[]).
  149. subst(X,[X|L],A,[A|M]) if
  150.       ! and
  151.       subst(X,L,A,M).
  152. subst(X,[Y|L],A,[Y|M]) if 
  153.       subst(X,L,A,M).
  154.       
  155.        
  156. /* 
  157. IS THE FIRST PARAMETER A SUBSET OF THE SECOND?
  158. */
  159. subset([A|X],Y) if
  160.        member(A,Y) and
  161.        subset(X,Y).
  162. subset([],_).
  163.  
  164. /*
  165. INTERSECTION(X,Y,Z) SUCCEEDS IF THE INTERSECTION OF X AND Y IS Z
  166. */
  167. intersection([],_,[]).
  168. intersection([X|R],Y,[X|Z]) if
  169.        member(X,Y) and
  170.        ! and
  171.        intersection(R,Y,Z).
  172. intersection([_|R],Y,Z) if
  173.        intersection(R,Y,Z).
  174.        
  175. /*
  176. UNION(X,Y,Z) SUCCEEDS IF THE UNION OF X AND Y IS Z
  177. */
  178. union([],X,X).
  179. union([X|R],Y,Z) if
  180.     member(X,Y) and
  181.     ! and
  182.     union(R,Y,Z).
  183. union([X|R],Y,[X|Z]) if
  184.     union(R,Y,Z).
  185. /*
  186. SORT A LIST OF SYMBOLS
  187. */
  188. quicksort([],[]).
  189. quicksort([H|T],S) if
  190.        split(H,T,A,B) and
  191.        quicksort(A,A1) and
  192.        quicksort(B,B1) and
  193.        append(A1,[H|B1],S).
  194. split(H,[A|X],[A|Y],Z) if A <= H and split(H,X,Y,Z).
  195. split(H,[A|X],Y,[A|Z]) if A > H and split(H,X,Y,Z).
  196. split(_,[],[],[]).
  197.  
  198.